package com.woniuxy.gobang84.ui;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

import com.woniuxy.gobang84.entity.Piece;
import com.woniuxy.gobang84.util.Global;

import javafx.collections.ObservableList;
import javafx.event.EventHandler;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.Button;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.Background;
import javafx.scene.layout.BackgroundFill;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Line;
import javafx.scene.text.Font;
import javafx.stage.DirectoryChooser;
import javafx.stage.FileChooser;
import javafx.stage.Stage;

/**
 * 单机版主棋盘窗口
 *
 * @author 老谭 (<a href="http://www.woniuxy.com">蜗牛学苑</a>)
 *
 */
public class GameMain extends Stage {

	public GameMain() {
		// 编写界面代码内容
		// 设置窗体标题
		this.setTitle("蜗牛五子棋");
		// 设计窗体内容
		// 创建布局容器对象(面板)
		Pane pane = new Pane();
		// 设置面板颜色
		// pane.setBackground(new Background(new BackgroundFill(new Color(0.5,0.5,0,1),
		// null, null)));
		pane.setBackground(new Background(new BackgroundFill(Color.CHOCOLATE, null, null)));
		// 绘制棋盘
		drawCheckerBoard(pane);

		// 为面板添加鼠标点击事件
		pane.setOnMouseClicked(new EventHandler<MouseEvent>() {

			@Override
			public void handle(MouseEvent event) {
				// 判断游戏是否结束
				if (Global.GAME_OVER) {
					return;
				}
				// System.out.println("鼠标点击"+event.getX()+":"+event.getY());
				// 1、如何使棋子颜色交替出现；√ 2、如何实现只能在棋盘范围内落子; √
				// 判断点击坐标是否在落子范围
				double x = event.getX();
				double y = event.getY();
				if (x < Global.GAME_CHECKERBOARD_MARGIN_SIZE - Global.GAME_CHECKERBOARD_CELL_SIZE / 2
						|| x > Global.GAME_CHECKERBOARD_MARGIN_SIZE + Global.GAME_CHECKERBOARD_LINE_LEN
								+ Global.GAME_CHECKERBOARD_CELL_SIZE / 2
						|| y < Global.GAME_CHECKERBOARD_MARGIN_SIZE - Global.GAME_CHECKERBOARD_CELL_SIZE / 2
						|| y > Global.GAME_CHECKERBOARD_MARGIN_SIZE + Global.GAME_CHECKERBOARD_LINE_LEN
								+ Global.GAME_CHECKERBOARD_CELL_SIZE / 2) {
					return;
				}
				// 3、如何让棋子落在十字中央(棋子矫正位置)√
				// 矫正坐标
				double pieceX = ((int) ((x - Global.GAME_CHECKERBOARD_MARGIN_SIZE
						+ Global.GAME_CHECKERBOARD_CELL_SIZE / 2) / Global.GAME_CHECKERBOARD_CELL_SIZE))
						* Global.GAME_CHECKERBOARD_CELL_SIZE + Global.GAME_CHECKERBOARD_MARGIN_SIZE;
				double pieceY = ((int) ((y - Global.GAME_CHECKERBOARD_MARGIN_SIZE
						+ Global.GAME_CHECKERBOARD_CELL_SIZE / 2) / Global.GAME_CHECKERBOARD_CELL_SIZE))
						* Global.GAME_CHECKERBOARD_CELL_SIZE + Global.GAME_CHECKERBOARD_MARGIN_SIZE;
				// 4、落子防重
				if (containPiece(pieceX, pieceY)) {
					return;
				}
				// 绘制圆形
				Circle circle = new Circle(pieceX, pieceY, Global.GAME_PIECE_RADIUS);
				// 将落子信息定义对象进行存储
				Piece piece;
				if (Global.GAME_PIECE_STATE_FIRST) {
					circle.setFill(Global.GAME_PIECE_FIRST);
					piece = new Piece(pieceX, pieceY, Global.GAME_PIECE_FIRST);
				} else {
					circle.setFill(Global.GAME_PIECE_NEXT);
					piece = new Piece(pieceX, pieceY, Global.GAME_PIECE_NEXT);
				}

				// 棋子状态切换
				Global.GAME_PIECE_STATE_FIRST = !Global.GAME_PIECE_STATE_FIRST;
				pane.getChildren().add(circle);
				// 将落子信息添加到数组
				savePiece(piece);

				// 输赢判断
				isWin(piece);
			}

		});

		addNewBtn(pane);
		// 添加悔棋按钮
		addRegretBtn(pane);
		// 保存棋谱按钮
		addSaveBtn(pane, this);
		// 打谱按钮
		addReproduceBtn(pane, this);

		// 创建舞台内容容器对象
		Scene scene = new Scene(pane, Global.GAME_WINDOW_WIDTH, Global.GAME_WINDOW_HEIGHT);

		// 将舞台内容容器对象关联到舞台对象中
		setScene(scene);
		// 设置窗体大小不可调整
		setResizable(false);
		// 显示窗体
		show();
	}

	public void addReproduceBtn(Pane pane, Stage primaryStage) {
		// 添加悔棋按钮
		Button reproduceBtn = new Button("打谱");
		// 设置宽高
		reproduceBtn.setPrefSize(Global.BTN_WIDTH, Global.BTN_HEIGHT);
		// 设置字体样式和尺寸
		reproduceBtn.setFont(new Font(Global.BTN_TEXT_TYPE, Global.BTN_TEXT_SIZE));
		// 设置位置
		reproduceBtn.setLayoutX(Global.REPRODUCE_BTN_X);
		reproduceBtn.setLayoutY(Global.REPRODUCE_BTN_Y);
		// 设置字体颜色
		reproduceBtn.setTextFill(Color.ALICEBLUE);
		// 设置背景
		reproduceBtn.setBackground(new Background(new BackgroundFill(Color.BLUE, null, null)));
		// 添加监听代码
		reproduceBtn.setOnMouseClicked(new EventHandler<MouseEvent>() {

			@Override
			public void handle(MouseEvent event) {
				/*
				 * 打谱 1、文件选择弹框，找到棋谱文件 2、将棋谱文件转为ArrayList(持久状态数据转为瞬时状态数据) 3、清空已有棋子数据;
				 * 4、创建上一步、下一步、退出按钮
				 */
//				1、文件选择弹框，找到棋谱文件
				FileChooser fc = new FileChooser();
				fc.setTitle("选择棋谱文件");
				File file = fc.showOpenDialog(primaryStage);
//				2、将棋谱文件转为ArrayList(持久状态数据转为瞬时状态数据)
				FileInputStream fis = null;
				ObjectInputStream ois = null;
				try {
					fis = new FileInputStream(file);
					ois = new ObjectInputStream(fis);
					Global.CVS_PIECES = (ArrayList<Piece>) ois.readObject();
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					try {
						ois.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
					try {
						fis.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
//				3、清空已有棋子数据;
				clearPiece(pane);
//				4、创建上一步、下一步、退出按钮
				Button reBtn = addReproducePrevBtn(pane);
				Button reNBtn = addReproduceNextBtn(pane);
				addReproduceExitBtn(pane, reBtn, reNBtn);
			}

			public void addReproduceExitBtn(Pane pane, Button re1, Button re2) {
				// 添加退出按钮
				Button exitNextBtn = new Button("X");
				// 设置宽高
				exitNextBtn.setPrefSize(Global.BTN_WIDTH / 4, Global.BTN_HEIGHT / 3);
				// 设置位置
				exitNextBtn.setLayoutX(Global.REPRODUCE_EXIT_BTN_X);
				exitNextBtn.setLayoutY(Global.REPRODUCE_EXIT_BTN_Y);
				exitNextBtn.setOnMouseClicked(new EventHandler<MouseEvent>() {

					@Override
					public void handle(MouseEvent event) {
						// 移除打谱相关按钮
						pane.getChildren().remove(exitNextBtn);
						pane.getChildren().remove(re1);
						pane.getChildren().remove(re2);
					}
				});
				// 将按钮添加到面板
				pane.getChildren().add(exitNextBtn);
			}

			public Button addReproduceNextBtn(Pane pane) {
				// 添加下一步按钮
				Button reproduceNextBtn = new Button(">");
				// 设置宽高
				reproduceNextBtn.setPrefSize(Global.BTN_WIDTH / 4, Global.BTN_HEIGHT / 3);
				// 设置位置
				reproduceNextBtn.setLayoutX(Global.REPRODUCE_NEXT_BTN_X);
				reproduceNextBtn.setLayoutY(Global.REPRODUCE_NEXT_BTN_Y);
				// 添加监听器代码
				reproduceNextBtn.setOnMouseClicked(new EventHandler<MouseEvent>() {

					@Override
					public void handle(MouseEvent event) {
						if (Global.CVS_INDEX >= Global.CVS_PIECES.size()) {
							return;
						}
						// 取出棋子对象
						Piece oldPiece = Global.CVS_PIECES.get(Global.CVS_INDEX++);
						// 绘制圆形
						Circle circle = new Circle(oldPiece.getX(), oldPiece.getY(), Global.GAME_PIECE_RADIUS);
						// 将落子信息定义对象进行存储
						if (Global.GAME_PIECE_STATE_FIRST) {
							circle.setFill(Global.GAME_PIECE_FIRST);
							oldPiece.setColor(Global.GAME_PIECE_FIRST);
						} else {
							circle.setFill(Global.GAME_PIECE_NEXT);
							oldPiece.setColor(Global.GAME_PIECE_NEXT);
						}
						// 棋子状态切换
						Global.GAME_PIECE_STATE_FIRST = !Global.GAME_PIECE_STATE_FIRST;
						pane.getChildren().add(circle);
						// 将落子信息添加到数组
						savePiece(oldPiece);
						// 输赢判断
						isWin(oldPiece);
					}
				});
				// 将按钮添加到面板
				pane.getChildren().add(reproduceNextBtn);
				return reproduceNextBtn;
			}

			public Button addReproducePrevBtn(Pane pane) {
				// 添加上一步按钮
				Button reproducePrevBtn = new Button("<");
				// 设置宽高
				reproducePrevBtn.setPrefSize(Global.BTN_WIDTH / 4, Global.BTN_HEIGHT / 3);
				// 设置位置
				reproducePrevBtn.setLayoutX(Global.REPRODUCE_PREV_BTN_X);
				reproducePrevBtn.setLayoutY(Global.REPRODUCE_PREV_BTN_Y);
				// 将按钮添加到面板
				pane.getChildren().add(reproducePrevBtn);
				return reproducePrevBtn;
			}
		});
		// 将按钮添加到面板
		pane.getChildren().add(reproduceBtn);
	}

	public void addSaveBtn(Pane pane, Stage primaryStage) {
		// 添加悔棋按钮
		Button saveBtn = new Button("保存棋谱");
		// 设置宽高
		saveBtn.setPrefSize(Global.BTN_WIDTH, Global.BTN_HEIGHT);
		// 设置字体样式和尺寸
		saveBtn.setFont(new Font(Global.BTN_TEXT_TYPE, Global.BTN_TEXT_SIZE));
		// 设置位置
		saveBtn.setLayoutX(Global.SAVE_BTN_X);
		saveBtn.setLayoutY(Global.SAVE_BTN_Y);
		// 添加监听器代码
		saveBtn.setOnMouseClicked(new EventHandler<MouseEvent>() {

			@Override
			public void handle(MouseEvent event) {
				// 判断是否存在落子信息
				if (Global.PIECES.size() < 1) {
					return;
				}
				/*
				 * 保存棋谱 1、弹窗文件夹选择框，让用户选择要保存的位置； 2、生成棋谱文件名称(.csv);
				 * 3、将PIECE数据转成持久状态(ObjectOutputStream);
				 */
//				1、弹窗文件夹选择框，让用户选择要保存的位置；
				DirectoryChooser dc = new DirectoryChooser();
				dc.setTitle("选择棋谱保存位置");
				File file = dc.showDialog(primaryStage);
//				2、生成棋谱文件名称(.csv);
				String fileName = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss").format(new Date()) + "_gobang.csv";
//				3、将PIECE数据转成持久状态(ObjectOutputStream);
				// 创建文件节点流
				FileOutputStream fos = null;
				ObjectOutputStream oos = null;
				try {
					fos = new FileOutputStream(new File(file, fileName));
					// 创建处理流
					oos = new ObjectOutputStream(fos);
					// 将棋子信息存储到文件中
					oos.writeObject(Global.PIECES);
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					try {
						oos.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
					try {
						fos.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		});
		// 将按钮添加到面板
		pane.getChildren().add(saveBtn);
	}

	/**
	 * 增加悔棋按钮
	 * 
	 * @param pane
	 */
	public void addRegretBtn(Pane pane) {
		// 添加悔棋按钮
		Button regretBtn = new Button("悔棋");
		// 设置宽高
		regretBtn.setPrefSize(Global.BTN_WIDTH, Global.BTN_HEIGHT);
		// 设置字体样式和尺寸
		regretBtn.setFont(new Font(Global.BTN_TEXT_TYPE, Global.BTN_TEXT_SIZE));
		// 设置位置
		regretBtn.setLayoutX(Global.REGRET_BTN_X);
		regretBtn.setLayoutY(Global.REGRET_BTN_Y);
		// 添加监听器代码
		regretBtn.setOnMouseClicked(new EventHandler<MouseEvent>() {
			@Override
			public void handle(MouseEvent event) {
				// 悔棋功能
				if (Global.GAME_OVER) {
					return;
				}
				/*
				 * 1、将上一颗棋子从棋盘移除; 2、将上一颗棋子对象从PIECES中移除; 3、对棋子状态进行取反;
				 * 
				 */
				// 获取存储面板元素的集合对象
				ObservableList<Node> list = pane.getChildren();
				// 如何防止移除除棋子以外的对象？
				if (Global.PIECES.size() > 0) {
					list.remove(list.size() - 1);
//					2、将上一颗棋子对象从PIECES中移除;
					Global.PIECES.remove(Global.PIECES.size() - 1);
//					3、对棋子状态进行取反;
					Global.GAME_PIECE_STATE_FIRST = !Global.GAME_PIECE_STATE_FIRST;
				}

			}
		});
		// 将按钮添加到面板
		pane.getChildren().add(regretBtn);
	}

	public void addNewBtn(Pane pane) {
		// 添加新局按钮
		Button newBtn = new Button("新局");
		// 设置宽高
		newBtn.setPrefSize(Global.BTN_WIDTH, Global.BTN_HEIGHT);
		// 设置字体样式和尺寸
		newBtn.setFont(new Font(Global.BTN_TEXT_TYPE, Global.BTN_TEXT_SIZE));
		// 设置位置
		newBtn.setLayoutX(Global.NEW_BTN_X);
		newBtn.setLayoutY(Global.NEW_BTN_Y);
		// 添加监听器代码
		newBtn.setOnMouseClicked(t -> clearPiece(pane));
//		newBtn.setOnMouseClicked(new EventHandler<MouseEvent>() {
//
//			@Override
//			public void handle(MouseEvent event) {
//				// 新局
//				/*
//				 * 1、清除棋盘上的棋子数据; 2、清空PIECES中所有棋子信息; 3、棋子颜色进行初始化; 4、重置gameOver;
//				 */
//				clearPiece(pane);
//			}
//		});
		// 将按钮添加到面板
		pane.getChildren().add(newBtn);
	}

	public void clearPiece(Pane pane) {
		// 1、清除棋盘上的棋子数据;
		// 获取存储面板元素的集合对象
		ObservableList<Node> list = pane.getChildren();
		// removeIf():遍历当前集合所有元素，分别调用test方法，根据test方法返回结果决定是否移除当前元素
		list.removeIf(t -> t instanceof Circle);
		// 2、清空PIECES中所有棋子信息;
		Global.PIECES.clear();
		// 3、棋子颜色进行初始化;
		Global.GAME_PIECE_STATE_FIRST = true;
		// 4、重置gameOver;
		Global.GAME_OVER = false;
	}

	// 判断指定坐标是否存在棋子
	private boolean containPiece(double pieceX, double pieceY) {
		for (int index = 0; index < Global.PIECES.size(); index++) {
			Piece oldPiece = Global.PIECES.get(index);
			if (oldPiece != null && oldPiece.getX() == pieceX && oldPiece.getY() == pieceY) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 将指定棋子对象存储到数组中 将指定棋子对象存储到数组中
	 * 
	 * @param piece
	 */
	private void savePiece(Piece piece) {
		Global.PIECES.add(piece);
		// for(int index=0;index<Global.PIECES.size();index++){
		// if(Global.PIECES.get(index)==null){
		// Global.PIECES.add(piece);
		// break;
		// }
		// }
	}

	public void isWin(Piece piece) {
		// 水平方法
		// 存储同色连棋数量
		int count = 1;
		// 向左<-
		for (int j = 1; j < 5; j++) {
			boolean state = false;
			for (int index = 0; index < Global.PIECES.size(); index++) {
				// 旧棋子
				Piece oldPiece = Global.PIECES.get(index);
				// 目标坐标
				double aimX = piece.getX() - Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				double aimY = piece.getY();
				/*
				 * if(oldPiece!=null && oldPiece.getX()==aimX && oldPiece.getY()==aimY &&
				 * oldPiece.getColor().equals(piece.getColor())){
				 */
				// 将目标棋子信息存储到对象
				Piece aimPiece = new Piece(aimX, aimY, piece.getColor());
				// 比较目标棋子与数组中棋子对象进行比较(坐标和颜色是否相同)
				if (aimPiece.equals(oldPiece)) {
					// 计数加一
					count++;
					// 将棋子状态设置为找到
					state = true;
					break;
				}
			}
			// 如果目标棋子未找到(说明不是连子)，结束此方向查找
			if (!state) {
				break;
			}
		}
		// 向右 ->
		for (int j = 1; j < 5; j++) {
			boolean state = false;
			for (int index = 0; index < Global.PIECES.size(); index++) {
				// 旧棋子
				Piece oldPiece = Global.PIECES.get(index);
				// 目标坐标
				double aimX = piece.getX() + Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				double aimY = piece.getY();
				/*
				 * if(oldPiece!=null && oldPiece.getX()==aimX && oldPiece.getY()==aimY &&
				 * oldPiece.getColor().equals(piece.getColor())){
				 */
				Piece aimPiece = new Piece(aimX, aimY, piece.getColor());
				if (aimPiece.equals(oldPiece)) {
					count++;
					state = true;
					break;
				}
			}
			if (!state) {
				break;
			}
		}
		if (count > 4) {
			// 消息框
			// Alert alert=new Alert()
			showWinInfor();
			Global.GAME_OVER = true;
			return;
		}
		// 重置count
		count = 1;
		// 垂直方向判断
		// 向上
		for (int j = 1; j < 5; j++) {
			boolean state = false;
			for (int index = 0; index < Global.PIECES.size(); index++) {
				// 旧棋子
				Piece oldPiece = Global.PIECES.get(index);
				// 目标坐标
				double aimX = piece.getX();
				double aimY = piece.getY() - Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				/*
				 * if(oldPiece!=null && oldPiece.getX()==aimX && oldPiece.getY()==aimY &&
				 * oldPiece.getColor().equals(piece.getColor())){
				 */
				Piece aimPiece = new Piece(aimX, aimY, piece.getColor());
				if (aimPiece.equals(oldPiece)) {
					count++;
					state = true;
					break;
				}
			}
			if (!state) {
				break;
			}
		}
		// 向下
		for (int j = 1; j < 5; j++) {
			boolean state = false;
			for (int index = 0; index < Global.PIECES.size(); index++) {
				// 旧棋子
				Piece oldPiece = Global.PIECES.get(index);
				// 目标坐标
				double aimX = piece.getX();
				double aimY = piece.getY() + Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				/*
				 * if(oldPiece!=null && oldPiece.getX()==aimX && oldPiece.getY()==aimY &&
				 * oldPiece.getColor().equals(piece.getColor())){
				 */
				Piece aimPiece = new Piece(aimX, aimY, piece.getColor());
				if (aimPiece.equals(oldPiece)) {
					count++;
					state = true;
					break;
				}
			}
			if (!state) {
				break;
			}
		}
		if (count > 4) {
			showWinInfor();
			Global.GAME_OVER = true;
			return;
		}
		// 重置count
		count = 1;
		// 从左上到右下斜向判断\
		// 左上角
		for (int j = 1; j < 5; j++) {
			boolean state = false;
			for (int index = 0; index < Global.PIECES.size(); index++) {
				// 旧棋子
				Piece oldPiece = Global.PIECES.get(index);
				// 目标坐标
				double aimX = piece.getX() - Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				double aimY = piece.getY() - Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				/*
				 * if(oldPiece!=null && oldPiece.getX()==aimX && oldPiece.getY()==aimY &&
				 * oldPiece.getColor().equals(piece.getColor())){
				 */
				Piece aimPiece = new Piece(aimX, aimY, piece.getColor());
				if (aimPiece.equals(oldPiece)) {
					count++;
					state = true;
					break;
				}
			}
			if (!state) {
				break;
			}
		}
		// 右下角判断
		for (int j = 1; j < 5; j++) {
			boolean state = false;
			for (int index = 0; index < Global.PIECES.size(); index++) {
				// 旧棋子
				Piece oldPiece = Global.PIECES.get(index);
				// 目标坐标
				double aimX = piece.getX() + Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				double aimY = piece.getY() + Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				/*
				 * if(oldPiece!=null && oldPiece.getX()==aimX && oldPiece.getY()==aimY &&
				 * oldPiece.getColor().equals(piece.getColor())){
				 */
				Piece aimPiece = new Piece(aimX, aimY, piece.getColor());
				if (aimPiece.equals(oldPiece)) {
					count++;
					state = true;
					break;
				}
			}
			if (!state) {
				break;
			}
		}
		if (count > 4) {
			showWinInfor();
			Global.GAME_OVER = true;
			return;
		}
		// 重置count
		count = 1;
		// 从左下到右上斜向判断/
		// 左下角
		for (int j = 1; j < 5; j++) {
			boolean state = false;
			for (int index = 0; index < Global.PIECES.size(); index++) {
				// 旧棋子
				Piece oldPiece = Global.PIECES.get(index);
				// 目标坐标
				double aimX = piece.getX() - Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				double aimY = piece.getY() + Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				/*
				 * if(oldPiece!=null && oldPiece.getX()==aimX && oldPiece.getY()==aimY &&
				 * oldPiece.getColor().equals(piece.getColor())){
				 */
				Piece aimPiece = new Piece(aimX, aimY, piece.getColor());
				if (aimPiece.equals(oldPiece)) {
					count++;
					state = true;
					break;
				}
			}
			if (!state) {
				break;
			}
		}
		// 右上角判断
		for (int j = 1; j < 5; j++) {
			boolean state = false;
			for (int index = 0; index < Global.PIECES.size(); index++) {
				// 旧棋子
				Piece oldPiece = Global.PIECES.get(index);
				// 目标坐标
				double aimX = piece.getX() + Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				double aimY = piece.getY() - Global.GAME_CHECKERBOARD_CELL_SIZE * j;
				/*
				 * if(oldPiece!=null && oldPiece.getX()==aimX && oldPiece.getY()==aimY &&
				 * oldPiece.getColor().equals(piece.getColor())){
				 */
				Piece aimPiece = new Piece(aimX, aimY, piece.getColor());
				if (aimPiece.equals(oldPiece)) {
					count++;
					state = true;
					break;
				}
			}
			if (!state) {
				break;
			}
		}
		if (count > 4) {
			showWinInfor();
			Global.GAME_OVER = true;
			return;
		}
	}

	public void showWinInfor() {
		String mes;
		if (Global.GAME_PIECE_STATE_FIRST) {
			mes = "后手";
		} else {
			mes = "先手";
		}
		Alert alert = new Alert(AlertType.INFORMATION);
		// 设置消息内容
		alert.setContentText("恭喜" + mes + "赢得了比赛!");
		// 设置标题
		alert.setTitle("对战结果: ");
		// 展示弹窗
		alert.show();
	}

	private void drawCheckerBoard(Pane pane) {
		// 水平线条绘制
		for (int row = 0; row <= Global.GAME_CHECKERBOARD_CELL_NUM; row++) {
			// 绘制棋盘
			Line line = new Line(Global.GAME_CHECKERBOARD_MARGIN_SIZE,
					Global.GAME_CHECKERBOARD_MARGIN_SIZE + Global.GAME_CHECKERBOARD_CELL_SIZE * row,
					Global.GAME_CHECKERBOARD_MARGIN_SIZE + Global.GAME_CHECKERBOARD_LINE_LEN,
					Global.GAME_CHECKERBOARD_MARGIN_SIZE + Global.GAME_CHECKERBOARD_CELL_SIZE * row);

			// 将组件添加到面板容器
			pane.getChildren().add(line);
		}
		// 垂直线条绘制
		for (int col = 0; col <= Global.GAME_CHECKERBOARD_CELL_NUM; col++) {
			// 绘制棋盘
			Line line = new Line(Global.GAME_CHECKERBOARD_MARGIN_SIZE + Global.GAME_CHECKERBOARD_CELL_SIZE * col,
					Global.GAME_CHECKERBOARD_MARGIN_SIZE,
					Global.GAME_CHECKERBOARD_MARGIN_SIZE + Global.GAME_CHECKERBOARD_CELL_SIZE * col,
					Global.GAME_CHECKERBOARD_MARGIN_SIZE + Global.GAME_CHECKERBOARD_LINE_LEN);

			// 将组件添加到面板容器
			pane.getChildren().add(line);
		}
	}
}
